import json
import os
import random
import sys
import threading
import time
import tkinter as tk
import winreg  # 添加 winreg 导入
from datetime import date
from tkinter import messagebox, ttk

import matplotlib.pyplot as plt
import pygame  # 添加到文件开头的导入部分
import pystray
from PIL import Image
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from plyer import notification
from win32con import SC_MONITORPOWER, WM_SYSCOMMAND
from win32gui import SendMessage


class RestReminderApp:
    DEFAULT_WORK_TIME = 40
    DEFAULT_REST_TIME = 5
    DEFAULT_MICRO_INTERVAL = 20
    ICON_PATHS = {
        'window': 'clock.ico',
        'tray': 'icon.png',
        'notification': 'icon.ico'
    }

    def __init__(self, master):
        self.master = master
        master.title("智能休息提醒器")
        master.geometry("400x530")

        # 获取资源文件路径
        if getattr(sys, 'frozen', False):
            # 如果是打包后的 exe
            self.base_path = sys._MEIPASS
        else:
            # 如果是开发环境
            self.base_path = os.path.dirname(os.path.abspath(__file__))

        # 设置窗口图标
        try:
            icon_path = os.path.join(self.base_path, 'resources', 'clock.ico')
            master.iconbitmap(icon_path)
        except (tk.TclError, Exception) as e:  # 修改异常类型
            print(f"无法加载窗口图标: {e}")

        # 设置系统托盘
        self.setup_tray_icon()

        # 设置主题样式
        self.setup_styles()

        # 创建选项卡
        self.tab_control = ttk.Notebook(master)
        self.main_tab = ttk.Frame(self.tab_control)
        self.settings_tab = ttk.Frame(self.tab_control)  # 新增功能设置标签页
        self.stats_tab = ttk.Frame(self.tab_control)
        self.manual_tab = ttk.Frame(self.tab_control)

        self.tab_control.add(self.main_tab, text='主界面')
        self.tab_control.add(self.settings_tab, text='功能设置')  # 添加功能设置标签
        self.tab_control.add(self.stats_tab, text='统计')
        self.tab_control.add(self.manual_tab, text='使用说明')
        self.tab_control.pack(expand=1, fill="both")

        # 主界面组件
        self.setup_main_tab()
        # 功能设置组件
        self.setup_settings_tab()
        # 统计界面组件
        self.setup_stats_tab()
        # 使用说明界面组件
        self.setup_manual_tab()

        # 计时控制变量
        self.is_running = False
        self.remaining = 0
        self.total_time = 0
        self.rest_remaining = 0
        self.is_resting = False
        self.warning_time = 0  # 添加提醒时间变量
        self.micro_reminder_interval = 1200  # 默认20分钟微提醒

        # 加载统计数据
        self.stats = self.load_stats()
        self.update_stats_display()

        # 初始化声音系统
        pygame.mixer.init()
        try:
            sound_path = os.path.join(self.base_path, 'resources', 'reminder.wav')
            self.reminder_sound = pygame.mixer.Sound(sound_path)  # 加载提醒音效
        except Exception as e:
            print(f"无法加载提醒音效: {e}")
            self.reminder_sound = None

        # 加载休息建议
        try:
            suggestions_path = os.path.join(self.base_path, 'resources', 'rest_suggestions.json')
            with open(suggestions_path, 'r', encoding='utf-8') as f:
                self.rest_suggestions = json.load(f)
        except Exception as e:
            print(f"无法加载休息建议: {e}")
            self.rest_suggestions = {}

    def setup_styles(self):
        """设置自定义样式"""
        style = ttk.Style()

        # 设置主题
        style.theme_use('clam')  # 使用 clam 主题作为基础

        # 自定义按钮样式
        style.configure('TButton', padding=5)
        style.configure('Accent.TButton',
                        background='#0078D7',
                        foreground='white',
                        padding=5)

        # 自定义标签框样式
        style.configure('TLabelframe',
                        padding=5,
                        relief='solid')

        # 自定义文本框样式
        style.configure('TEntry',
                        padding=5)

        # 设置简单的背景色
        self.master.configure(background='#f0f0f0')  # 使用浅灰色背景

        # 按钮增加悬停效果
        style.map('Accent.TButton',
                  background=[('active', '#005299'), ('!active', '#0078D7')])

    def setup_main_tab(self):
        # 工作时间设置
        work_frame = ttk.LabelFrame(self.main_tab, text="工作时间设置")
        work_frame.pack(pady=5, padx=5, fill="x")

        self.time_label = tk.Label(work_frame, text="工作时间（分钟）:")
        self.time_label.pack(pady=5)
        self.time_entry = tk.Entry(work_frame)
        self.time_entry.pack(pady=5)
        self.time_entry.insert(0, self.DEFAULT_WORK_TIME)

        # 休息时间设置
        rest_frame = ttk.LabelFrame(self.main_tab, text="休息时间设置")
        rest_frame.pack(pady=5, padx=5, fill="x")

        self.rest_label = tk.Label(rest_frame, text="休息时间（分钟）:")
        self.rest_label.pack(pady=5)
        self.rest_entry = tk.Entry(rest_frame)
        self.rest_entry.pack(pady=5)
        self.rest_entry.insert(0, self.DEFAULT_REST_TIME)

        # 剩余时间显示
        time_display_frame = ttk.Frame(self.main_tab)
        time_display_frame.pack(pady=5)

        self.remaining_label = tk.Label(time_display_frame, text="剩余时间: --:--")
        self.remaining_label.pack(side=tk.LEFT, padx=5)

        self.warning_label = tk.Label(time_display_frame, text="(将在 --:-- 时提醒)")
        self.warning_label.pack(side=tk.LEFT, padx=5)

        # 控制按钮
        button_frame = ttk.Frame(self.main_tab)
        button_frame.pack(pady=10)

        self.start_btn = tk.Button(button_frame, text="开始计时", command=self.start_timer)
        self.start_btn.pack(side=tk.LEFT, padx=5)

        self.stop_btn = tk.Button(button_frame, text="停止计时", command=self.stop_timer, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=5)

        self.skip_btn = tk.Button(button_frame, text="忽略提醒", command=self.skip_rest, state=tk.DISABLED)
        self.skip_btn.pack(side=tk.LEFT, padx=5)

        # 绑定窗口关闭事件
        self.master.protocol("WM_DELETE_WINDOW", self.on_closing)

    def setup_settings_tab(self):
        """设置功能设置标签页"""
        # 微提醒设置
        micro_reminder_frame = ttk.LabelFrame(self.settings_tab, text="微提醒设置")
        micro_reminder_frame.pack(pady=5, padx=5, fill="x")

        self.micro_reminder_label = tk.Label(micro_reminder_frame, text="微提醒间隔（分钟）:")
        self.micro_reminder_label.pack(pady=5)
        self.micro_reminder_entry = tk.Entry(micro_reminder_frame)
        self.micro_reminder_entry.pack(pady=5)
        self.micro_reminder_entry.insert(0, self.DEFAULT_MICRO_INTERVAL)

        # 模式选择
        mode_frame = ttk.LabelFrame(self.settings_tab, text="模式设置")
        mode_frame.pack(pady=5, padx=5, fill="x")

        self.force_mode = tk.BooleanVar()
        self.force_check = tk.Checkbutton(mode_frame, text="启用强制休息模式", variable=self.force_mode)
        self.force_check.pack(pady=5)

        # 提醒音效设置
        sound_frame = ttk.LabelFrame(self.settings_tab, text="提醒音效设置")
        sound_frame.pack(pady=5, padx=5, fill="x")

        self.sound_enabled = tk.BooleanVar(value=True)
        self.sound_check = tk.Checkbutton(
            sound_frame,
            text="启用提醒音效",
            variable=self.sound_enabled
        )
        self.sound_check.pack(pady=5)

        # 音量控制
        volume_frame = ttk.Frame(sound_frame)
        volume_frame.pack(fill="x", padx=5)
        ttk.Label(volume_frame, text="音量:").pack(side=tk.LEFT)
        self.volume_scale = ttk.Scale(
            volume_frame,
            from_=0,
            to=100,
            orient="horizontal"
        )
        self.volume_scale.set(50)  # 默认音量50%
        self.volume_scale.pack(side=tk.LEFT, fill="x", expand=True)

        # 添加开机自启动设置
        startup_frame = ttk.LabelFrame(self.settings_tab, text="启动设置")
        startup_frame.pack(pady=5, padx=5, fill="x")

        self.auto_start = tk.BooleanVar()
        self.auto_start.set(self.check_auto_start())  # 检查当前自启动状态
        self.auto_start_check = tk.Checkbutton(
            startup_frame,
            text="开机自动启动",
            variable=self.auto_start,
            command=self.toggle_auto_start
        )
        self.auto_start_check.pack(pady=5)

    def setup_stats_tab(self):
        # 创建统计文本框
        self.stats_text = tk.Text(self.stats_tab, height=20, width=40)
        self.stats_text.pack(pady=10, padx=10)
        self.stats_text.config(state=tk.DISABLED)

        # 添加图表展示
        try:
            fig = plt.Figure(figsize=(5, 3))
            ax = fig.add_subplot(111)
            canvas = FigureCanvasTkAgg(fig, self.stats_tab)
            canvas.get_tk_widget().pack()
        except Exception as e:
            print(f"图表创建失败: {e}")

    def setup_manual_tab(self):
        """设置使用说明标签页"""
        # 创建文本框
        text_widget = tk.Text(self.manual_tab,
                              wrap=tk.WORD,
                              padx=15,
                              pady=15,
                              font=('Microsoft YaHei UI', 10),
                              bg='#F9F9F9',
                              relief='solid',
                              borderwidth=1)
        text_widget.pack(expand=True, fill="both", padx=10, pady=10)

        # 添加滚动条
        scrollbar = ttk.Scrollbar(self.manual_tab, orient="vertical", command=text_widget.yview)
        scrollbar.pack(side="right", fill="y")
        text_widget.configure(yscrollcommand=scrollbar.set)

        # 插入使用手册内容
        manual_content = """使用手册

1. 基本设置
   - 工作时间：设置一次工作的持续时间
   - 休息时间：设置休息的持续时间
   - 微提醒间隔：设置定期提醒的时间间隔

2. 功能设置
   - 开机自启动：设置程序随系统启动
   - 强制休息模式：时间到会强制关闭显示器
   - 提醒音效：可调节音量或关闭

3. 提醒系统
   - 进度提醒：工作时间过半时提醒
   - 定期微提醒：根据设定的间隔定期提醒
   - 休息提醒：结束时推荐休息活动

4. 统计功能
   - 查看每日工作和休息时间
   - 统计跳过休息的次数
   - 记录总体使用情况

5. 操作说明
   - 点击"开始计时"启动程序
   - 点击"停止计时"终止当前计时
   - 点击"忽略提醒"跳过休息时间
   - 最小化到系统托盘继续运行

6. 休息建议
   - 提供多样化的运动建议
   - 包含颈部/眼部/伸展运动
   - 具体步骤指导

7. 注意事项
   - 建议工作时间不要超过60分钟
   - 建议休息时间不少于5分钟
   - 建议开启强制休息模式
   - 请勿频繁跳过休息时间

8. 关于软件
   智能休息提醒器 v1.1
   
   新增功能：
   - 休息活动建议
   - 开机自启动支持
   - 更智能的提醒系统

   作者：FFGGFFGFV
   联系方式：ffggffgfv@qq.com"""

        text_widget.insert("1.0", manual_content)
        text_widget.config(state="disabled")  # 设置为只读

    def load_stats(self):
        try:
            with open('rest_stats.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            return {
                'total_work_time': 0,  # 总工作时间（分钟）
                'total_rest_time': 0,  # 总休息时间（分钟）
                'skipped_rests': 0,  # 跳过的休息次数
                'daily_records': {}  # 每日记录
            }

    def save_stats(self):
        try:
            with open('rest_stats.json', 'w') as f:
                json.dump(self.stats, f)
        except Exception as e:
            print(f"统计保存失败: {e}")
            # 添加自动备份机制
            with open('rest_stats_backup.json', 'w') as f:
                json.dump(self.stats, f)

    def update_stats(self, work_time=0, rest_time=0, skipped=False):
        today = str(date.today())
        if today not in self.stats['daily_records']:
            self.stats['daily_records'][today] = {
                'work_time': 0,
                'rest_time': 0,
                'skipped_rests': 0
            }

        self.stats['total_work_time'] += work_time
        self.stats['total_rest_time'] += rest_time
        self.stats['daily_records'][today]['work_time'] += work_time
        self.stats['daily_records'][today]['rest_time'] += rest_time

        if skipped:
            self.stats['skipped_rests'] += 1
            self.stats['daily_records'][today]['skipped_rests'] += 1

        self.save_stats()
        self.update_stats_display()

    def update_stats_display(self):
        self.stats_text.config(state=tk.NORMAL)
        self.stats_text.delete(1.0, tk.END)

        # 总体统计
        self.stats_text.insert(tk.END, "===== 总体统计 =====\n")
        self.stats_text.insert(tk.END, f"总工作时间: {self.stats['total_work_time']}分钟\n")
        self.stats_text.insert(tk.END, f"总休息时间: {self.stats['total_rest_time']}分钟\n")
        self.stats_text.insert(tk.END, f"跳过休息次数: {self.stats['skipped_rests']}次\n\n")

        # 今日统计
        today = str(date.today())
        self.stats_text.insert(tk.END, "===== 今日统计 =====\n")
        if today in self.stats['daily_records']:
            daily = self.stats['daily_records'][today]
            self.stats_text.insert(tk.END, f"工作时间: {daily['work_time']}分钟\n")
            self.stats_text.insert(tk.END, f"休息时间: {daily['rest_time']}分钟\n")
            self.stats_text.insert(tk.END, f"跳过次数: {daily.get('skipped_rests', 0)}次\n")
        else:
            self.stats_text.insert(tk.END, "今天还没有记录\n")

        self.stats_text.config(state=tk.DISABLED)

    def start_timer(self):
        if not self.is_running:
            try:
                # 添加启动提示
                self.show_reminder("计时器已启动", "系统提示")
                work_minutes = int(self.time_entry.get())
                rest_minutes = int(self.rest_entry.get())
                micro_minutes = int(self.micro_reminder_entry.get())

                if work_minutes <= 0 or rest_minutes <= 0 or micro_minutes <= 0:
                    raise ValueError

                self.total_time = work_minutes * 60
                self.remaining = self.total_time
                self.rest_time = rest_minutes * 60
                self.micro_reminder_interval = micro_minutes * 60

                # 计算提醒时间
                eighth_time = self.total_time / 8  # 工作时间的八分之一
                self.warning_time = min(300, eighth_time)  # 取5分钟和八分之一中的较小值
                warning_minutes = int(self.warning_time // 60)
                warning_seconds = int(self.warning_time % 60)
                self.warning_label.config(text=f"(将在 {warning_minutes:02d}:{warning_seconds:02d} 时提醒)")

                self.is_running = True
                self.start_btn.config(state=tk.DISABLED)
                self.stop_btn.config(state=tk.NORMAL)
                self.time_entry.config(state=tk.DISABLED)
                self.rest_entry.config(state=tk.DISABLED)

                threading.Thread(target=self.timer_thread, daemon=True).start()
            except ValueError:
                messagebox.showerror("错误", "请输入有效的正整数值")

    def stop_timer(self):
        self.is_running = False
        self.is_resting = False
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.skip_btn.config(state=tk.DISABLED)
        self.time_entry.config(state=tk.NORMAL)
        self.rest_entry.config(state=tk.NORMAL)
        self.remaining_label.config(text="剩余时间: --:--")
        self.warning_label.config(text="(将在 --:-- 时提醒)")

    def skip_rest(self):
        if self.is_resting:
            self.update_stats(work_time=self.total_time // 60, skipped=True)
            self.stop_timer()

    def timer_thread(self):
        last_micro_reminder = self.total_time  # 记录上次微提醒的时间

        while self.is_running and self.remaining > 0:
            time.sleep(1)
            self.remaining -= 1

            minutes = self.remaining // 60
            seconds = self.remaining % 60
            self.update_gui(lambda: self.remaining_label.config(
                text=f"剩余时间: {self.format_time(self.remaining)}"))

            # 多阶段提醒系统
            # 1. 强制休息提醒
            if self.force_mode.get() and self.remaining == self.warning_time:
                warning_minutes = int(self.warning_time // 60)
                warning_seconds = int(self.warning_time % 60)
                self.show_reminder(f"{warning_minutes:02d}:{warning_seconds:02d}后将强制休息！")

            # 2. 50%进度提醒
            if self.remaining == self.total_time // 2:
                half_time = self.total_time // 2 // 60
                self.show_reminder(f"已完成50%工作时间！\n已工作{half_time}分钟，继续加油！")

            # 3. 12.5%时间点提醒（新增）
            if self.remaining == self.warning_time:
                remaining_minutes = self.remaining // 60
                remaining_seconds = self.remaining % 60
                self.show_reminder(
                    f"即将进入休息时间！\n"
                    f"还剩 {remaining_minutes:02d}:{remaining_seconds:02d}",
                    title="休息预告"
                )

            # 4. 定期微提醒
            time_since_last = last_micro_reminder - self.remaining
            if (time_since_last >= self.micro_reminder_interval and
                    self.remaining != self.total_time and
                    self.remaining > self.warning_time):  # 避免与强制休息提醒冲突

                worked_minutes = (self.total_time - self.remaining) // 60
                self.show_micro_reminder(worked_minutes)
                last_micro_reminder = self.remaining

            if self.remaining <= 0:
                if self.force_mode.get():
                    self.start_rest(force=True)
                else:
                    self.start_rest(force=False)

    def start_rest(self, force=False):
        self.is_resting = True
        self.skip_btn.config(state=tk.NORMAL)
        self.show_reminder("休息时间到，请休息！")

        if force:
            self.force_rest()
            self.update_stats(work_time=self.total_time // 60, rest_time=self.rest_time // 60)

        self.remaining = self.rest_time
        while self.is_running and self.is_resting and self.remaining > 0:
            time.sleep(1)
            self.remaining -= 1

            minutes = self.remaining // 60
            seconds = self.remaining % 60
            self.update_gui(lambda: self.remaining_label.config(
                text=f"休息剩余: {self.format_time(self.remaining)}"))

        if self.remaining <= 0 and self.is_resting:
            self.show_reminder("休息结束，继续工作吧！")
            self.update_stats(work_time=self.total_time // 60, rest_time=self.rest_time // 60)
            self.stop_timer()

    def show_micro_reminder(self, worked_minutes):
        """显示微提醒，带有随机的建议内容"""
        suggestions = [
            "请起身活动一下，做个简单伸展",
            "建议远眺放松一下眼睛",
            "喝口水补充水分",
            "做几次深呼吸",
            "活动一下脖子和手腕",
            "建议起身走动一下"
        ]
        suggestion = random.choice(suggestions)
        self.show_reminder(
            f"已连续工作{worked_minutes}分钟\n{suggestion}",
            title="友情提醒"
        )

    def show_reminder(self, message, title="休息提醒"):
        """显示系统通知"""
        try:
            # 播放提醒音效
            if (hasattr(self, 'reminder_sound') and
                    self.reminder_sound and
                    self.sound_enabled.get()):
                self.reminder_sound.set_volume(self.volume_scale.get() / 100)
                self.reminder_sound.play()

            # 如果是休息提醒，添加运动建议
            if title == "休息提醒" and message == "休息时间到，请休息！":
                exercise = self.get_random_exercise()
                if exercise:
                    message = self.format_exercise_message(exercise)

            # 获取正确的图标路径
            if getattr(sys, 'frozen', False):
                icon_path = os.path.join(sys._MEIPASS, 'resources', 'icon.ico')
            else:
                icon_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'resources', 'icon.ico')

            # 发送系统通知
            notification.notify(
                title=title,
                message=message,
                app_name="智能休息提醒器",
                app_icon=icon_path,
                timeout=15  # 延长通知显示时间到15秒
            )
        except Exception as e:
            print(f"通知发送失败: {e}")
            # 如果系统通知失败，尝试使用备用通知方式
            self.update_gui(lambda: messagebox.showinfo(title, message))

    def get_random_exercise(self):
        """获取随机休息建议"""
        if not self.rest_suggestions:
            return None
            
        # 随机选择一个类别
        category = random.choice(list(self.rest_suggestions.keys()))
        category_data = self.rest_suggestions[category]
        
        # 随机选择该类别中的一个运动
        exercise = random.choice(category_data['exercises'])
        
        return {
            'title': category_data['title'],
            'name': exercise['name'],
            'steps': exercise['steps']
        }

    def format_exercise_message(self, exercise):
        """格式化运动建议消息"""
        if not exercise:
            return "休息一下，活动活动吧！"
            
        message = f"{exercise['title']} - {exercise['name']}\n\n"
        message += "\n".join(exercise['steps'])
        return message

    def force_rest(self):
        if sys.platform == 'win32':
            try:
                SendMessage(0xFFFF, WM_SYSCOMMAND, SC_MONITORPOWER, 2)
            except Exception as e:
                messagebox.showerror("错误", f"无法关闭显示器: {str(e)}")
        elif sys.platform == 'darwin':
            os.system('pmset displaysleepnow')  # MacOS
        else:
            # Linux方案
            pass  # 添加空语句保持语法正确

    def setup_tray_icon(self):
        """设置系统托盘图标"""

        def left_click(icon, item):
            self.show_window()

        # 创建托盘菜单
        menu = (
            pystray.MenuItem("显示", self.show_window),
            pystray.MenuItem("退出", self.quit_app)
        )

        # 创建系统托盘图标
        try:
            icon_path = os.path.join(self.base_path, 'resources', 'icon.png')
            icon_image = Image.open(icon_path)
            self.tray_icon = pystray.Icon(
                "rest_reminder",
                icon_image,
                "智能休息提醒器",
                menu
            )
            self.tray_icon.on_click = left_click
            threading.Thread(target=self.tray_icon.run, daemon=True).start()
        except Exception as e:
            print(f"无法加载托盘图标: {e}")
            # 创建一个默认图标
            icon_image = Image.new('RGB', (64, 64), color='gray')
            self.tray_icon = pystray.Icon(
                "rest_reminder",
                icon_image,
                "智能休息提醒器",
                menu
            )
            self.tray_icon.on_click = left_click
            threading.Thread(target=self.tray_icon.run, daemon=True).start()

    def show_window(self, icon=None, item=None):
        """显示主窗口"""
        self.master.deiconify()  # 显示窗口
        self.master.focus_force()  # 强制获取焦点

    def quit_app(self):
        # 添加资源释放
        if hasattr(self, 'tray_icon'):
            self.tray_icon.stop()
        if self.is_running:
            self.stop_timer()
        # 退出声音系统
        pygame.mixer.quit()
        self.master.destroy()

    def on_closing(self):
        """窗口关闭时最小化到托盘"""
        self.master.withdraw()  # 隐藏窗口

    @staticmethod
    def format_time(seconds):
        """统一时间格式化方法"""
        return f"{seconds // 60:02d}:{seconds % 60:02d}"

    def update_gui(self, callback):
        """统一GUI更新方法"""
        self.master.after(0, callback)

    def toggle_auto_start(self):
        """切换开机自启动状态"""
        try:
            if self.auto_start.get():
                self.set_auto_start()
            else:
                self.remove_auto_start()
        except Exception as e:
            messagebox.showerror("错误", f"设置开机自启动失败: {str(e)}")
            self.auto_start.set(not self.auto_start.get())  # 恢复复选框状态

    def set_auto_start(self):
        """设置开机自启动"""
        key = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER,
            r"Software\Microsoft\Windows\CurrentVersion\Run",
            0,
            winreg.KEY_SET_VALUE
        )

        # 获取当前执行文件的路径
        if getattr(sys, 'frozen', False):
            # 如果是打包后的exe
            app_path = sys.executable
        else:
            # 如果是python脚本
            app_path = sys.argv[0]
            # 使用pythonw.exe来运行（无控制台窗口）
            python_path = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe')
            app_path = f'"{python_path}" "{app_path}"'

        winreg.SetValueEx(
            key,
            "智能休息提醒器",
            0,
            winreg.REG_SZ,
            app_path
        )
        winreg.CloseKey(key)

    def remove_auto_start(self):
        """删除开机自启动"""
        key = winreg.OpenKey(
            winreg.HKEY_CURRENT_USER,
            r"Software\Microsoft\Windows\CurrentVersion\Run",
            0,
            winreg.KEY_SET_VALUE
        )
        try:
            winreg.DeleteValue(key, "智能休息提醒器")
        except WindowsError:
            pass  # 如果键不存在，忽略错误
        winreg.CloseKey(key)

    def check_auto_start(self):
        """检查是否已设置开机自启动"""
        try:
            key = winreg.OpenKey(
                winreg.HKEY_CURRENT_USER,
                r"Software\Microsoft\Windows\CurrentVersion\Run",
                0,
                winreg.KEY_READ
            )
            try:
                winreg.QueryValueEx(key, "智能休息提醒器")
                return True
            except WindowsError:
                return False
            finally:
                winreg.CloseKey(key)
        except WindowsError:
            return False


if __name__ == "__main__":
    root = tk.Tk()
    # 设置任务栏图标
    try:
        import ctypes

        myappid = 'ffggffgfv.restreminder.1.0'  # 任意字符串，但要保持唯一性
        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)

        if getattr(sys, 'frozen', False):
            base_path = sys._MEIPASS
        else:
            base_path = os.path.dirname(os.path.abspath(__file__))

        icon_path = os.path.join(base_path, 'resources', 'clock.ico')
        root.iconbitmap(icon_path)
    except Exception as e:
        print(f"无法设置任务栏图标: {e}")

    app = RestReminderApp(root)
    root.mainloop()
